// 用户管理页面
const { getUsers, getUserStats, adminUpdateUser, deleteUser } = require('../../../api/user');

Page({
  data: {
    // 页面状态
    loading: false,
    
    // 统计数据
    stats: {
      totalUsers: 0,
      activeUsers: 0,
      disabledUsers: 0,
      newUsers: 0
    },
    
    // 全局加载状态
    globalLoading: false,
    globalLoadingText: '管理数据加载中...',
    
    // 用户列表
    users: [],
    allUsers: [], // 原始数据
    
    // 搜索和筛选
    searchKeyword: '',
    currentFilter: 'all',
    
    // 空状态信息
    emptyState: {
      type: 'no_data', // no_data, no_search_result, no_filter_result
      title: '暂无用户数据',
      desc: '请检查筛选条件或稍后重试',
      showReset: false
    },
    
    // 弹窗状态
    showUserDetailModal: false,
    showEditModal: false,
    selectedUser: {},
    
    // 编辑表单
    editForm: {
      id: '',
      name: '',
      id_card: '',
      gender: '',
      genderIndex: 0,
      birth_date: '',
      phone: '',
      email: '',
      regionValue: [], // 省市区选择器的值数组
      regionDisplay: '', // 省市区显示文本
      village: '',
      address: '',
      postal_code: '',
      status: 'active',
      statusIndex: 0
    },
    
    // 状态选项
    statusOptions: [
      { value: 'active', text: '正常' },
      { value: 'banned', text: '已禁用' }
    ],
    
    // 性别选项
    genderOptions: [
      { value: '', text: '请选择性别' },
      { value: 'male', text: '男' },
      { value: 'female', text: '女' },
      { value: 'secrecy', text: '保密' }
    ],
    
    // 表单验证错误
    errors: {}
  },

  // 显示全局加载
  showGlobalLoading(text = '管理数据加载中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  onLoad() {
    // 页面加载时获取所有非管理员用户数据
    this.loadUsers();
    this.loadStats();
  },

  onShow() {
    // 页面显示时刷新数据
    this.loadUsers();
    this.loadStats();
  },

  onUnload() {
    // 页面卸载时清理定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer);
      this.searchTimer = null;
    }
    if (this.filterTimer) {
      clearTimeout(this.filterTimer);
      this.filterTimer = null;
    }
  },

  // 下拉刷新
  onPullDownRefresh() {
    // 重新加载数据
    Promise.all([
      this.loadUsers(),
      this.loadStats()
    ]).then(() => {
      // 停止下拉刷新动画
      wx.stopPullDownRefresh();
    }).catch(() => {
      // 即使出错也要停止刷新动画
      wx.stopPullDownRefresh();
    });
  },

  // 更新空状态信息
  updateEmptyState(users, searchKeyword, currentFilter) {
    let emptyState = {
      type: 'no_data',
      title: '暂无用户数据',
      desc: '请检查筛选条件或稍后重试',
      showReset: false
    };

    if (users.length === 0) {
      if (searchKeyword && searchKeyword.trim()) {
        // 有搜索关键词但没有结果
        emptyState = {
          type: 'no_search_result',
          title: '未找到匹配的用户',
          desc: `没有找到包含"${searchKeyword}"的用户`,
          showReset: true
        };
      } else if (currentFilter !== 'all') {
        // 有筛选条件但没有结果
        const filterTextMap = {
          'active': '正常用户',
          'disabled': '已禁用用户'
        };
        const filterText = filterTextMap[currentFilter] || '用户';
        emptyState = {
          type: 'no_filter_result',
          title: `暂无${filterText}`,
          desc: `当前筛选条件下没有${filterText}`,
          showReset: true
        };
      } else {
        // 没有任何数据
        emptyState = {
          type: 'no_data',
          title: '暂无用户数据',
          desc: '系统中还没有用户数据',
          showReset: false
        };
      }
    }

    this.setData({ emptyState });
  },

  // 加载用户列表
  async loadUsers() {
    this.setData({ loading: true });
    
    try {
      // 调用API获取所有非管理员用户数据
      // 状态映射：前端disabled对应后端banned
      const statusMapping = {
        'all': 'all',
        'active': 'active', 
        'disabled': 'banned'
      };
      
      const response = await getUsers({
        page: 1,
        pageSize: 100, // 获取更多数据用于前端筛选
        keyword: this.data.searchKeyword || '',
        status: statusMapping[this.data.currentFilter] || 'all'
      });
      
      if (response.success) {
        // 格式化用户数据，添加状态文本和地址信息
        const formattedUsers = response.data.users.map(user => ({
          ...user,
          statusText: user.status === 'active' ? '正常' : user.status === 'inactive' ? '未激活' : user.status === 'banned' ? '已禁用' : '未知状态',
          location: this.formatUserLocation(user),
          registerTime: this.formatDateTime(user.createdAt),
          lastLoginTime: user.lastLoginTime ? this.formatDateTime(user.lastLoginTime) : '从未登录',
          // 处理头像URL，如果是相对路径则添加服务器地址
          avatar: user.avatar ? this.formatAvatarUrl(user.avatar) : ''
        }));
        
        this.setData({
          users: formattedUsers,
          allUsers: formattedUsers,
          loading: false
        });
        
        // 更新空状态信息
        this.updateEmptyState(formattedUsers, this.data.searchKeyword, this.data.currentFilter);
        
        // 显示加载成功提示（仅在下拉刷新时显示）
        if (formattedUsers.length > 0) {
          wx.showToast({
            title: '刷新成功',
            icon: 'success',
            duration: 1500
          });
        }
        
        return Promise.resolve();
      } else {
        throw new Error(response.message || '获取用户列表失败');
      }
    } catch (error) {
      console.error('加载用户列表失败:', error);
      wx.showToast({
        title: '加载失败',
        icon: 'error'
      });
      this.setData({ loading: false });
      return Promise.reject(error);
    }
  },

  // 加载统计数据
  async loadStats() {
    try {
      // 调用API获取用户统计数据
      const response = await getUserStats();
      
      if (response.success) {
        // 确保所有统计数据都有默认值0，避免显示undefined
        const statsData = response.data || {};
        this.setData({
          stats: {
            totalUsers: statsData.totalUsers || 0,
            activeUsers: statsData.activeUsers || 0,
            disabledUsers: statsData.disabledUsers || 0,
            newUsers: statsData.newUsers || 0
          }
        });
      } else {
        console.warn('获取统计数据失败:', response.message);
        // 即使API失败，也确保显示0
        this.setData({
          stats: {
            totalUsers: 0,
            activeUsers: 0,
            disabledUsers: 0,
            newUsers: 0
          }
        });
      }
    } catch (error) {
      console.error('加载统计数据失败:', error);
      // 即使出错，也确保显示0
      this.setData({
        stats: {
          totalUsers: 0,
          activeUsers: 0,
          disabledUsers: 0,
          newUsers: 0
        }
      });
    }
  },

  // 格式化用户地址信息
  formatUserLocation(user) {
    const { province, city, county, address } = user;
    let location = '';
    
    if (province) location += province;
    if (city) location += city;
    if(county) location += county;
    if (address) location += address;
    
    return location || '未设置地址';
  },

  // 格式化日期时间
  formatDateTime(dateTime) {
    if (!dateTime) return '';
    
    const date = new Date(dateTime);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    const seconds = String(date.getSeconds()).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
  },

  // 格式化日期为微信小程序日期选择器格式 (YYYY-MM-DD)
  formatDateForPicker(dateTime) {
    if (!dateTime) return '';
    
    const date = new Date(dateTime);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    
    return `${year}-${month}-${day}`;
  },


  // 搜索输入
  onSearchInput(e) {
    const value = e.detail.value;
    this.setData({
      searchKeyword: value
    });
    
    // 清除之前的搜索定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer);
    }
    
    // 如果搜索框为空，立即执行筛选
    if (!value || !value.trim()) {
      this.performSearch();
      return;
    }
    
    // 使用防抖延迟执行搜索，避免频繁API调用
    this.searchTimer = setTimeout(() => {
      this.performSearch();
    }, 500);
  },

  // 执行搜索
  onSearch() {
    this.performSearch();
  },

  // 执行搜索操作
  async performSearch() {
    try {
      this.setData({ loading: true });
      await this.loadUsers();
    } catch (error) {
      console.error('搜索失败:', error);
      this.setData({ loading: false });
    }
  },

  // 清除搜索
  onClearSearch() {
    this.setData({
      searchKeyword: ''
    });
    
    // 清除搜索定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer);
    }
    
    this.performSearch();
  },

  // 重置筛选条件
  onResetFilters() {
    this.setData({
      searchKeyword: '',
      currentFilter: 'all'
    });
    this.loadUsers();
  },

  // 筛选用户（保留用于前端快速筛选，但主要依赖API）
  filterUsers() {
    const { allUsers, searchKeyword, currentFilter } = this.data;
    let filteredUsers = [...allUsers];

    // 按关键词搜索
    if (searchKeyword && searchKeyword.trim()) {
      const keyword = searchKeyword.toLowerCase();
      filteredUsers = filteredUsers.filter(user => 
        user.name.toLowerCase().includes(keyword) ||
        user.phone.includes(keyword) ||
        (user.email && user.email.toLowerCase().includes(keyword))
      );
    }

    // 按状态筛选
    if (currentFilter !== 'all') {
      // 状态映射：前端disabled对应后端banned
      const statusMapping = {
        'active': 'active',
        'disabled': 'banned'
      };
      const filterStatus = statusMapping[currentFilter] || currentFilter;
      filteredUsers = filteredUsers.filter(user => user.status === filterStatus);
    }

    this.setData({
      users: filteredUsers,
      loading: false
    });
    
    // 更新空状态信息
    this.updateEmptyState(filteredUsers, searchKeyword, currentFilter);
  },

  // 切换筛选条件
  onFilterChange(e) {
    const filter = e.currentTarget.dataset.filter;
    
    // 如果筛选条件没有变化，直接返回
    if (filter === this.data.currentFilter) {
      return;
    }
    
    // 设置筛选状态和loading状态
    this.setData({
      currentFilter: filter,
      loading: true
    });
    
    // 使用防抖延迟执行筛选，避免频繁操作
    if (this.filterTimer) {
      clearTimeout(this.filterTimer);
    }
    
    this.filterTimer = setTimeout(() => {
      this.performFilter();
    }, 150);
  },

  // 执行筛选操作
  async performFilter() {
    try {
      // 如果有搜索关键词，调用API进行服务端筛选
      if (this.data.searchKeyword && this.data.searchKeyword.trim()) {
        await this.loadUsers();
      } else {
        // 否则使用本地数据筛选，避免不必要的API调用
        this.filterUsers();
      }
    } catch (error) {
      console.error('筛选失败:', error);
      this.setData({ loading: false });
    }
  },

  // 查看用户详情
  onViewUserDetail(e) {
    const user = e.currentTarget.dataset.user;
    this.setData({
      selectedUser: user,
      showUserDetailModal: true
    });
  },

  // 隐藏用户详情弹窗
  onHideUserDetailModal() {
    this.setData({
      showUserDetailModal: false,
      selectedUser: {}
    });
  },

  // 编辑用户
  onEditUser(e) {
    const user = e.currentTarget.dataset.user;
    
    // 找到性别索引
    const genderIndex = this.data.genderOptions.findIndex(option => option.value === user.gender);
    
    // 处理省市区数据
    const regionValue = [];
    const regionDisplay = [];
    if (user.province) regionValue.push(user.province);
    if (user.city) regionValue.push(user.city);
    if (user.county) regionValue.push(user.county);
    
    if (regionValue.length > 0) {
      regionDisplay.push(user.province || '');
      regionDisplay.push(user.city || '');
      regionDisplay.push(user.county || '');
    }
    
    this.setData({
      selectedUser: user,
      editForm: {
        id: user.id,
        name: user.name || '',
        id_card: user.idCard || '',
        gender: user.gender || '',
        genderIndex: genderIndex >= 0 ? genderIndex : 0,
        birth_date: this.formatDateForPicker(user.birthDate),
        phone: user.phone || '',
        email: user.email || '',
        regionValue: regionValue,
        regionDisplay: regionDisplay.join(' '),
        village: user.village || '',
        address: user.address || '',
        postal_code: user.postalCode || '',
        status: user.status,
        statusIndex: this.getStatusIndex(user.status)
      },
      showEditModal: true,
      errors: {}
    });
  },

  // 从详情页编辑用户
  onEditUserFromDetail() {
    const { selectedUser } = this.data;
    
    // 找到性别索引
    const genderIndex = this.data.genderOptions.findIndex(option => option.value === selectedUser.gender);
    
    // 处理省市区数据
    const regionValue = [];
    const regionDisplay = [];
    if (selectedUser.province) regionValue.push(selectedUser.province);
    if (selectedUser.city) regionValue.push(selectedUser.city);
    if (selectedUser.county) regionValue.push(selectedUser.county);
    
    if (regionValue.length > 0) {
      regionDisplay.push(selectedUser.province || '');
      regionDisplay.push(selectedUser.city || '');
      regionDisplay.push(selectedUser.county || '');
    }
    
    this.setData({
      editForm: {
        id: selectedUser.id,
        name: selectedUser.name || '',
        id_card: selectedUser.idCard || '',
        gender: selectedUser.gender || '',
        genderIndex: genderIndex >= 0 ? genderIndex : 0,
        birth_date: this.formatDateForPicker(selectedUser.birthDate),
        phone: selectedUser.phone || '',
        email: selectedUser.email || '',
        regionValue: regionValue,
        regionDisplay: regionDisplay.join(' '),
        village: selectedUser.village || '',
        address: selectedUser.address || '',
        postal_code: selectedUser.postalCode || '',
        status: selectedUser.status,
        statusIndex: this.getStatusIndex(selectedUser.status)
      },
      showUserDetailModal: false,
      showEditModal: true,
      errors: {}
    });
  },

  // 隐藏编辑弹窗
  onHideEditModal() {
    this.setData({
      showEditModal: false,
      editForm: {
        id: '',
        name: '',
        id_card: '',
        gender: '',
        genderIndex: 0,
        birth_date: '',
        phone: '',
        email: '',
        regionValue: [],
        regionDisplay: '',
        village: '',
        address: '',
        postal_code: '',
        status: 'active',
        statusIndex: 0
      },
      errors: {}
    });
  },


  // 编辑表单输入
  onEditFormInput(e) {
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;
    
    this.setData({
      [`editForm.${field}`]: value
    });

    // 清除对应字段的错误
    if (this.data.errors[field]) {
      this.setData({
        [`errors.${field}`]: ''
      });
    }
  },


  // 状态选择
  onStatusChange(e) {
    const index = e.detail.value;
    const status = this.data.statusOptions[index].value;
    
    this.setData({
      'editForm.statusIndex': index,
      'editForm.status': status
    });
  },

  // 性别选择
  onGenderChange(e) {
    const index = e.detail.value;
    const gender = this.data.genderOptions[index].value;
    
    this.setData({
      'editForm.genderIndex': index,
      'editForm.gender': gender
    });
  },

  // 出生日期选择
  onBirthDateChange(e) {
    this.setData({
      'editForm.birth_date': e.detail.value
    });
  },

  // 省市区选择
  onRegionChange(e) {
    const regionValue = e.detail.value;
    const regionDisplay = regionValue.join(' ');
    
    this.setData({
      'editForm.regionValue': regionValue,
      'editForm.regionDisplay': regionDisplay
    });
  },


  // 提交编辑
  async onSubmitEdit() {
    const { editForm } = this.data;
    
    // 表单验证
    const errors = this.validateForm(editForm);
    if (Object.keys(errors).length > 0) {
      this.setData({ errors });
      return;
    }

    try {
      // 显示全局加载提示 - 使用更安全的方法
      const app = getApp();
      if (app && typeof app.showGlobalLoading === 'function') {
        app.showGlobalLoading({
          loadingText: '正在保存用户信息...'
        });
      } else {
        // 如果全局加载不可用，使用微信原生loading
        wx.showLoading({
          title: '正在保存用户信息...',
          mask: true
        });
      }
      
      // 处理省市区数据，将数组转换为单独的字段
      const updateData = {
        userId: editForm.id,
        name: editForm.name,
        idCard: editForm.id_card,
        // 只发送有效的性别值
        gender: editForm.gender && ['male', 'female', 'secrecy'].includes(editForm.gender) ? editForm.gender : undefined,
        birthDate: editForm.birth_date,
        phone: editForm.phone,
        email: editForm.email,
        // 处理省市区数据
        province: editForm.regionValue && editForm.regionValue[0] ? editForm.regionValue[0] : '',
        city: editForm.regionValue && editForm.regionValue[1] ? editForm.regionValue[1] : '',
        county: editForm.regionValue && editForm.regionValue[2] ? editForm.regionValue[2] : '',
        village: editForm.village,
        address: editForm.address,
        postalCode: editForm.postal_code,
        status: editForm.status
      };

      // 调用管理员修改用户信息API
      const response = await adminUpdateUser(updateData);
      
      // 隐藏全局加载 - 使用更安全的方法
      if (app && typeof app.hideGlobalLoading === 'function') {
        app.hideGlobalLoading();
      } else {
        wx.hideLoading();
      }
      
      if (response.success) {
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        });
        
        this.onHideEditModal();
        this.loadUsers(); // 重新加载用户列表
        this.loadStats(); // 重新加载统计数据
      } else {
        wx.showToast({
          title: response.message || '保存失败',
          icon: 'error'
        });
      }
      
    } catch (error) {
      console.error('保存用户信息失败:', error);
      // 确保在出错时也隐藏加载状态
      const app = getApp();
      if (app && typeof app.hideGlobalLoading === 'function') {
        app.hideGlobalLoading();
      } else {
        wx.hideLoading();
      }
      wx.showToast({
        title: '保存失败',
        icon: 'error'
      });
    }
  },


  // 表单验证
  validateForm(form) {
    const errors = {};

    // 必填字段验证
    if (!form.name.trim()) {
      errors.name = '请输入用户姓名';
    }

    if (!form.phone.trim()) {
      errors.phone = '请输入手机号';
    } else if (!/^1[3-9]\d{9}$/.test(form.phone)) {
      errors.phone = '请输入正确的手机号';
    }

    // 省市区必填验证
    if (!form.regionValue || form.regionValue.length === 0) {
      errors.region = '请选择省市区';
    }

    // 邮箱格式验证
    if (form.email && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(form.email)) {
      errors.email = '请输入正确的邮箱地址';
    }

    // 身份证号格式验证
    if (form.id_card && !/^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/.test(form.id_card)) {
      errors.id_card = '请输入正确的身份证号';
    }

    // 邮政编码格式验证
    if (form.postal_code && !/^\d{6}$/.test(form.postal_code)) {
      errors.postal_code = '请输入正确的邮政编码';
    }

    return errors;
  },

  // 更新用户信息（用于状态更新）
  async updateUser(userData) {
    try {
      // 如果是状态更新，调用禁用用户API
      if (userData.status) {
        // 这里应该调用相应的API来更新用户状态
        // 由于没有具体的API调用，这里只是更新本地数据
        const { users, allUsers } = this.data;
        const statusTextMap = {
          'active': '正常',
          'banned': '已禁用',
          'inactive': '未激活'
        };
        const updatedStatusText = statusTextMap[userData.status] || '未知状态';
        const updatedUsers = users.map(user => 
          user.id === userData.id ? { 
            ...user, 
            ...userData, 
            statusText: updatedStatusText
          } : user
        );
        const updatedAllUsers = allUsers.map(user => 
          user.id === userData.id ? { 
            ...user, 
            ...userData, 
            statusText: updatedStatusText
          } : user
        );
        
        this.setData({
          users: updatedUsers,
          allUsers: updatedAllUsers
        });
      }
    } catch (error) {
      throw error;
    }
  },



  // 删除用户
  async onDeleteUser(e) {
    const user = e.currentTarget.dataset.user;
    
    try {
      // 显示确认对话框
      const result = await new Promise((resolve) => {
        wx.showModal({
          title: '⚠️ 危险操作',
          content: `确定要永久删除用户"${user.name}"吗？\n\n⚠️ 此操作将永久删除该用户的所有相关数据，\n\n此操作不可撤销！`,
          confirmText: '确认删除',
          cancelText: '取消',
          confirmColor: '#ff4444',
          success: (res) => resolve(res.confirm),
          fail: () => resolve(false)
        });
      });
      
      if (!result) {
        return;
      }
      
      // 显示全局加载提示 - 使用更安全的方法
      const app = getApp();
      if (app && typeof app.showGlobalLoading === 'function') {
        app.showGlobalLoading({
          loadingText: '正在删除用户...'
        });
      } else {
        wx.showLoading({
          title: '正在删除用户...',
          mask: true
        });
      }
      
      // 调用删除用户API
      const response = await deleteUser({
        userId: user.id,
        confirmDelete: true
      });
      
      // 隐藏全局加载 - 使用更安全的方法
      if (app && typeof app.hideGlobalLoading === 'function') {
        app.hideGlobalLoading();
      } else {
        wx.hideLoading();
      }
      if (response.success) {
        wx.showToast({
          title: '用户删除成功',
          icon: 'success',
          duration: 2000
        });
        
        // 从本地数据中移除已删除的用户
        const { users, allUsers } = this.data;
        const updatedUsers = users.filter(u => u.id !== user.id);
        const updatedAllUsers = allUsers.filter(u => u.id !== user.id);
        
        this.setData({
          users: updatedUsers,
          allUsers: updatedAllUsers
        });
        
        // 更新空状态信息
        this.updateEmptyState(updatedUsers, this.data.searchKeyword, this.data.currentFilter);
        
        // 重新加载统计数据
        this.loadStats();
      } else {
        wx.showToast({
          title: response.message || '删除失败',
          icon: 'error'
        });
      }
      
    } catch (error) {
      console.error('删除用户失败:', error);
      // 确保在出错时也隐藏加载状态 - 使用更安全的方法
      const app = getApp();
      if (app && typeof app.hideGlobalLoading === 'function') {
        app.hideGlobalLoading();
      } else {
        wx.hideLoading();
      }
      wx.showToast({
        title: '删除失败',
        icon: 'error'
      });
    }
  },


  // 头像加载失败处理
  onAvatarError(e) {
    const index = e.currentTarget.dataset.index;
    const users = [...this.data.users];
    if (users[index]) {
      users[index].avatar = ''; // 清空无效的头像URL
      this.setData({ users });
    }
  },

  // 详情弹窗头像加载失败处理
  onDetailAvatarError() {
    const selectedUser = { ...this.data.selectedUser };
    selectedUser.avatar = ''; // 清空无效的头像URL
    this.setData({ selectedUser });
  },

  // 格式化头像URL
  formatAvatarUrl(avatarUrl) {
    if (!avatarUrl) return '';
    
    // 如果已经是完整的URL，直接返回
    if (avatarUrl.startsWith('http://') || avatarUrl.startsWith('https://')) {
      return avatarUrl;
    }
    
    // 如果是相对路径，添加服务器地址
    if (avatarUrl.startsWith('/uploads/')) {
      const app = getApp();
      const baseUrl = app.globalData.baseUrl || 'http://localhost:3000';
      return `${baseUrl}${avatarUrl}`;
    }
    
    // 其他情况直接返回
    return avatarUrl;
  },

  // 获取状态索引
  getStatusIndex(status) {
    const statusOptions = this.data.statusOptions;
    const index = statusOptions.findIndex(option => option.value === status);
    return index >= 0 ? index : 0;
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 阻止事件冒泡
  }
});
